
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.sgc.view.mbean;

import com.brain.core.common.UtilCore;
import com.brain.core.configuracion.WebServletContextListener;
import com.brain.core.dto.ParametroDto;
import com.brain.core.view.mbean.*;
import com.brain.core.exception.DAOException;
import com.brain.core.manager.RecursosManager;
import com.brain.core.view.util.ConstantesCore;
import com.brain.sgc.dto.ArbolCompetenciaDto;
import com.brain.sgc.dto.MofAutoridadOrganizaDto;
import com.brain.sgc.dto.MofConductaDto;
import com.brain.sgc.dto.MofConocimientoAdicionalDto;
import com.brain.sgc.dto.MofConocimientoOfiDto;
import com.brain.sgc.dto.MofEstudioDto;
import com.brain.sgc.dto.MofExperienciaDto;
import com.brain.sgc.dto.MofFuncionDto;
import com.brain.sgc.dto.MofIdiomaDto;
import com.brain.sgc.dto.MofRelaOrgExternoDto;
import com.brain.sgc.dto.MofSexoDto;
import com.brain.sgc.dto.PuestoDto;
import com.brain.sgc.manager.ArbolCompetenciaManager;
import com.brain.sgc.manager.MofAutoridadOrganizaManager;
import com.brain.sgc.manager.MofConductaManager;
import com.brain.sgc.manager.MofConocimientoAdicManager;
import com.brain.sgc.manager.MofConocimientoOfiManager;
import com.brain.sgc.manager.MofEstudioManager;
import com.brain.sgc.manager.MofExperienciaManager;
import com.brain.sgc.manager.MofFuncionManager;
import com.brain.sgc.manager.MofIdiomaManager;
import com.brain.sgc.manager.MofRelaOrgExternoManager;
import com.brain.sgc.manager.MofSexoManager;
import com.brain.sgc.manager.PuestoManager;
import com.brain.sgc.view.util.ConstantesSgc;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;
import javax.faces.event.ActionEvent;
import javax.persistence.Transient;
import org.apache.log4j.Logger;
import org.primefaces.event.SelectEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

/**
 *
 * @author Hvives
 */
@Controller("puestoMBean")
@Scope("session")
public class PuestoMBean extends GenericMBean implements Serializable {

    private static Logger logger = Logger.getLogger(PuestoMBean.class);
    @Resource
    private PuestoManager manager;
    @Resource
    private MofConductaManager conductaManager;
    @Resource
    private MofConocimientoAdicManager conocimientoAdicManager;
    @Resource
    private MofConocimientoOfiManager conocimientoOfiManager;
    @Resource
    private MofEstudioManager mofEstudioManager;
    @Resource
    private MofExperienciaManager mofExperienciaManager;
    @Resource
    private MofIdiomaManager mofIdiomaManager;
    @Resource
    private MofFuncionManager mofFuncionManager;
    @Resource
    private RecursosManager recursosManager;
    @Resource
    private MofSexoManager mofSexoManager;
    @Resource
    private ArbolCompetenciaManager arbolCompetenciaManager;
    @Resource
    private MofAutoridadOrganizaManager mofAutoridadOrganizaManager;
    @Resource
    private MofRelaOrgExternoManager mofRelaOrgExternoManager;
    
    private ArbolCompetenciaDto arbolCompetenciaDto;
    private List<ArbolCompetenciaDto> listaArbolCompetenciaFuncionclaveDto;
    private List<PuestoDto> lista;
    private List<ParametroDto> listaEstadosPuesto;
    private List<ParametroDto> listaEstadosPuestoHab;
    private List<ParametroDto> listaUnidadOrganicaFiltro;
    private List<ParametroDto> listaUnidadOrganica;
    private List<ParametroDto> listaAreas;
    private PuestoDto dto;
    private PuestoDto dtoFiltro;
    private String keyTitulo = "puesto.panel";
    @Autowired
    private ApplicationMBean applicationMBean;
    @Autowired
    private SessionMBean sessionMBean;
    private Boolean accesoBtnGuardar = Boolean.TRUE;
    private List<ParametroDto> listaFamiliaNuevo;
    private List<ParametroDto> listaFamiliaFiltro;
    @Resource
    private ArbolCompetenciaMBean arbolCompetenciaMBean;
    
    //Parametros MOF Conducta
    private MofConductaDto conductaDto;
    private ParametroDto conductaParametroDto;
    private List<ParametroDto> listaConducta;
    private String descripcionConducta;
    
    //Parametros MOF Experiencia
    private MofExperienciaDto mofExperienciaDto;
    private ParametroDto cargoDto;
    private Integer aniosExperiencia;
    private String descripcionExperiencia;
    
    //Parametros MOF Estudio
    private MofEstudioDto mofEstudioDto;
    private ParametroDto profesionDto;
    private List<ParametroDto> listaProfesion;
    
    //Parametros MOF Idioma
    private MofIdiomaDto mofIdiomaDto;
    private String oral;
    private String escrito;
    private ParametroDto idiomaParametroDto;
    private List<ParametroDto> listaIdioma;
    
    //Parametros MOF Conocimiento Adicional
    private MofConocimientoAdicionalDto mofConocimientoAdicDto;
    private List<ParametroDto> listaConocimienInforCMAC;
    private ParametroDto conocimientOficCmacDto;
    private String tituloConocAdic;
    private String descripcionConocAdic;
    
    //Parametros MOF Conocimiento Ofi
    private MofConocimientoOfiDto mofConocimientoOfiDto;
    private ParametroDto herramientaOfficeDto;
    private List<ParametroDto> listaHerramientaOffice;
    private String nivelConocOfi;
    
    //Parametros MOF Funcion
    private MofFuncionDto mofFuncionDto;
    private String descripcionFuncion;
    private Integer valorObjetivo;
    private ParametroDto estadoFuncionDto;
    private Boolean evaluar;
    
    //Parametros MOF sexo
    private MofSexoDto mofSexoDto;
    private ParametroDto sexoParametroDto;
    private List<ParametroDto> listaSexo;
    
    //Parametros MOF LINEA DE AUTORIDAD
    private MofAutoridadOrganizaDto mofLineaAutoridadDto;
    private List<MofAutoridadOrganizaDto> listaLineaAutoridad;
    private List<MofAutoridadOrganizaDto> listaLineaAutoridadSupervision;
    @Transient
    private Boolean desabilitarBotonProcesar = false;
    @Transient
    private Boolean desabilitarBotonProcesarSupervision = false;
    
    //Parametros MOF RELACIONES ORGANIZACIONALES
    private MofAutoridadOrganizaDto mofRelacionesOrgani;
    private MofRelaOrgExternoDto mofRelaOrgExternoDto;
    private List<MofAutoridadOrganizaDto> listaRelacionesOrgInt;
    private List<ParametroDto> listaRelaOrgInternas;
    private ParametroDto relaOrgExtParametroDto;
    @Transient
    private Boolean desabilitarBotonRelacionesOrg = false;
    
    //deshabilitar proposito pincipal
    private Long numeroPuestoHabilitado;

    public PuestoMBean() {
        this.dtoFiltro = new PuestoDto();
    }

    public String iniciar() {
        this.dto = null;
        this.lista = null;
        this.dtoFiltro = new PuestoDto();
        this.dtoFiltro.setFamiliaDto(new ParametroDto());
        this.dtoFiltro.setUnidadOrganicaDto(new ParametroDto());
        return ConstantesSgc.UrlNavegacion.URL_LISTA_PUESTO;
    }

    public String nuevo() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.NUEVO);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.lista = new ArrayList<PuestoDto>();
        this.dto = manager.inicializar();
        this.setEstadoFuncionDto(new ParametroDto(ConstantesSgc.Parametro.PUESTO_ESTADO_ACTIVO));
        return ConstantesSgc.UrlNavegacion.URL_PUESTO;
    }

    public String editar() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.EDITAR);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.setEstadoFuncionDto(new ParametroDto(ConstantesSgc.Parametro.PUESTO_ESTADO_ACTIVO));
        this.principal();  
        this.listaLineaAutoridad();
        this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
        this.mofLineaAutoridadDto.setPuestoDto(new PuestoDto());
        return ConstantesSgc.UrlNavegacion.URL_PUESTO;
    }
    
    public String editarArbolCompetencia() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.EDITAR);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        ArbolCompetenciaMBean arbolCompMBean = (ArbolCompetenciaMBean) WebServletContextListener.getApplicationContext().getBean("arbolCompetenciaMBean");
        arbolCompMBean.setPuestoDto(this.dto);
        this.arbolCompetenciaMBean.buscar();
        return ConstantesSgc.UrlNavegacion.URL_LISTA_ARBOL_COMPETENCIA;
    }

    public String ver() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.VER);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        //ApplicationHelper.cargarPropietarios(ConstantesSgc.Entidad.REQUERIMIENTO, this.dto.getId());
        return ConstantesSgc.UrlNavegacion.URL_PUESTO;
    }
    
    public void buscar(ActionEvent ae) {

        try {
            this.lista = this.manager.obtenerPuestos(this.dtoFiltro);
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }

    }

    public String guardar() {
        if (this.manager.guardar(this.dto) != null) {
            if(this.dto.getId()!=null){
                sessionMBean.setAccion(ConstantesSgc.Formulario.EDITAR);
                this.setEstadoFuncionDto(new ParametroDto(ConstantesSgc.Parametro.PUESTO_ESTADO_ACTIVO));
            }
        }
        return "";
    }

    public String retroceder() {
        buscar(null);
        sessionMBean.setAccion(ConstantesSgc.Formulario.LISTA);
        sessionMBean().setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean().getAccion()));
        return ConstantesSgc.UrlNavegacion.URL_LISTA_PUESTO;
    }
    
    private boolean isValidDatosEstudio(MofEstudioDto dto){
        boolean validaEstudio = Boolean.TRUE;
        try {
            if(this.mofEstudioManager.obtenerMofEstudioPorDto(dto)!=null 
                    && this.mofEstudioManager.obtenerMofEstudioPorDto(dto).size()>0){
                recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.estudio.error"));
                validaEstudio = false;
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        return validaEstudio;
    }
    
    private boolean isValidDatosIdioma(MofIdiomaDto dto){
        boolean validaIdioma = Boolean.TRUE;
        try {
            if(this.mofIdiomaManager.obtenerCantidad(dto) >0){
                recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.idioma.error"));
                validaIdioma = false;
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        return validaIdioma;
    }
    
    private boolean isValidDatosExperiencia(MofExperienciaDto dto){
        boolean validaExperiencia = Boolean.TRUE;
        try {
            if(this.mofExperienciaManager.obtenerMofExperienciaPorDto(dto)!=null 
                    && this.mofExperienciaManager.obtenerMofExperienciaPorDto(dto).size()>0){
                recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.experiencia.error"));
                validaExperiencia = false;
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        return validaExperiencia;
    }
    
    private boolean isValidDatosConducta(MofConductaDto dto){
        boolean validaConducta = Boolean.TRUE;
        try {
            if(this.conductaManager.obtenerMofConductaPorDto(dto)!=null 
                    && this.conductaManager.obtenerMofConductaPorDto(dto).size()>0){
                recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.conducta.error"));
                validaConducta = false;
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        return validaConducta;
    }
    
    private boolean isValidDatosConocOfimatica(MofConocimientoOfiDto dto){
        boolean validaConocOfimatica = Boolean.TRUE;
        try {
            if(this.conocimientoOfiManager.obtenerMofConocOfiPorDto(dto)!=null 
                    && this.conocimientoOfiManager.obtenerMofConocOfiPorDto(dto).size()>0){
                recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.informatica.error"));
                validaConocOfimatica = false;
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        return validaConocOfimatica;
    }
    
    private boolean isValidDatosConocAdicional(MofConocimientoAdicionalDto dto){
        boolean validaConocAdicional = Boolean.TRUE;
        try {
//            if(dto.getTitulo()==null || dto.getTitulo().equals("")){
//                recursosManager.showWarning("Debe ingresar un Título antes de agregar un registro.");
//                validaConocAdicional = false;
//            }
            
            if(dto.getDescripcion()==null || dto.getDescripcion().equals("")){
                recursosManager.showWarning("Debe ingresar una Descripción antes de agregar un registro.");
                validaConocAdicional = false;
            }
            
            if(this.conocimientoAdicManager.obtenerMofConocAdicPorDto(dto)!=null 
                    && this.conocimientoAdicManager.obtenerMofConocAdicPorDto(dto).size()>0){
                recursosManager.showWarning("El titulo ya ha sido registrado.");
                validaConocAdicional = false;
            }
        } catch (DAOException e) {
            logger.error(e);
        }
        return validaConocAdicional;
    }
    
    public void agregarEstudio() {
        try {
            MofEstudioDto mofEstudioDto = new MofEstudioDto();
            mofEstudioDto.setPuestoDto(this.dto);
            mofEstudioDto.setProfesionDto(this.profesionDto);
            if(isValidDatosEstudio(mofEstudioDto)==false){
                logger.info("Se aborta el grabado de MofEstudio");
                return;
            }
            this.mofEstudioManager.nuevo(mofEstudioDto);
            recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.profesionDto = null;
    }
    
    public void eliminarEstudio() {
        try {
            this.mofEstudioManager.eliminar(this.mofEstudioDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void agregarIdioma() {
        try {
            MofIdiomaDto mofIdiomaDto = new MofIdiomaDto();
            mofIdiomaDto.setPuestoDto(this.dto);
            mofIdiomaDto.setIdiomaDto(this.idiomaParametroDto);
            mofIdiomaDto.setOral(this.oral);
            mofIdiomaDto.setEscrito(this.escrito);
            if(isValidDatosIdioma(mofIdiomaDto)==false){
                logger.info("Se aborta el grabado de MofIdioma");
                return;
            }
            this.mofIdiomaManager.nuevo(mofIdiomaDto);
            recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.idiomaParametroDto = null;
        this.oral = null;
        this.escrito = null;
    }
    
    public void agregarPuestoLineaAutoridad(){
    try {
            MofAutoridadOrganizaDto lineaAutoDto= new MofAutoridadOrganizaDto();
            lineaAutoDto.setPuestoDto(this.dto);
            lineaAutoDto.setPuestoAuxDto(this.mofLineaAutoridadDto.getPuestoAuxDto());
            lineaAutoDto.setTipo(ConstantesSgc.ValoresConstantes.PUESTO_TABLA_LINEA_AUTORIDAD_RESPONSABILIDAD_VALOR);
            lineaAutoDto.setTabla(ConstantesSgc.ValoresConstantes.PUESTO_TIPO_LINEA_AUTORIDAD_RESPONSABILIDAD_DEPENDENCIA_VALOR);
            this.mofAutoridadOrganizaManager.nuevo(lineaAutoDto);
            this.listaLineaAutoridad();
            recuperarDtoPadre();
            
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
       this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
    }
    
    public void agregarPuestoLineaAutoridadSupervision(){
    try {
            MofAutoridadOrganizaDto lineaAutoDto= new MofAutoridadOrganizaDto();
            lineaAutoDto.setPuestoDto(this.dto);
            lineaAutoDto.setPuestoAuxDto(this.mofLineaAutoridadDto.getPuestoAuxDto());
            lineaAutoDto.setTipo(ConstantesSgc.ValoresConstantes.PUESTO_TIPO_LINEA_AUTORIDAD_RESPONSABILIDAD_SUPERVISION_VALOR);
            lineaAutoDto.setTabla(ConstantesSgc.ValoresConstantes.PUESTO_TABLA_LINEA_AUTORIDAD_RESPONSABILIDAD_VALOR);
            this.mofAutoridadOrganizaManager.nuevo(lineaAutoDto);
            this.listaLineaAutoridad();
            recuperarDtoPadre();
            
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
       this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
    }
    
    public void agregarRelaOrgInterna(){
    try {
            MofAutoridadOrganizaDto relaciOrgDto= new MofAutoridadOrganizaDto();
            relaciOrgDto.setPuestoDto(this.dto);
            relaciOrgDto.setPuestoAuxDto(this.mofLineaAutoridadDto.getPuestoAuxDto());
            relaciOrgDto.setTipo(ConstantesSgc.ValoresConstantes.PUESTO_TIPO_RELACIONES_ORGANIZACIONALES_INTERNAS_VALOR);
            relaciOrgDto.setTabla(ConstantesSgc.ValoresConstantes.PUESTO_TABLA_RELACIONES_ORGANIZACIONALES_VALOR);
            this.mofAutoridadOrganizaManager.nuevo(relaciOrgDto);
            this.listaLineaAutoridad();
            recuperarDtoPadre();
            
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
       this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
    }
    
    public void validarPuestoDependencia(SelectEvent event) {         
        try {
            this.mofLineaAutoridadDto.setPuestoDto(this.dto);
            List<MofAutoridadOrganizaDto> listaEvaComp= this.mofAutoridadOrganizaManager.obtenerCantidadLineaAutoridadDependencia(this.mofLineaAutoridadDto);
           if(listaEvaComp.size()>0){
           recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.linea.autoridad.error"));
           this.desabilitarBotonProcesar=true;
           this.mofLineaAutoridadDto = null;
           this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
           }else{this.desabilitarBotonProcesar=false;}
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }   
    }
    
    public void validarPuestoSupervision(SelectEvent event) {         
        try {
            this.mofLineaAutoridadDto.setPuestoDto(this.dto);
           List<MofAutoridadOrganizaDto> listaEvaComp= this.mofAutoridadOrganizaManager.obtenerCantidadLineaAutoridadSupervision(this.mofLineaAutoridadDto);
           if(listaEvaComp.size()>0){
           recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.linea.autoridad.error"));
           this.desabilitarBotonProcesarSupervision=true;
           this.mofLineaAutoridadDto = null;
           this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
           }else{this.desabilitarBotonProcesarSupervision=false;}
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }   
    }
    
     public void validarPuestoRelaOrgInterna(SelectEvent event) {         
        try {
            this.mofLineaAutoridadDto.setPuestoDto(this.dto);
            List<MofAutoridadOrganizaDto> listaEvaComp= this.mofAutoridadOrganizaManager.obtenerCantidadRelacionesOrgInterna(this.mofLineaAutoridadDto);
            if(listaEvaComp.size()>0){
            recursosManager.showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.linea.autoridad.error"));
            this.desabilitarBotonRelacionesOrg=true;
            this.mofLineaAutoridadDto = null;
            this.mofLineaAutoridadDto = new MofAutoridadOrganizaDto();
           }else{this.desabilitarBotonRelacionesOrg=false;}
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }   
    }
    
    public void eliminarPuesto(){
        try {
            this.mofAutoridadOrganizaManager.eliminar(this.mofLineaAutoridadDto);
            this.listaLineaAutoridad();
            this.recuperarDtoPadre();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        
    }
    
    public void eliminarIdioma() {
        try {
            this.mofIdiomaManager.eliminar(this.mofIdiomaDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void agregarExperiencia() {
        try {
            MofExperienciaDto mofExperienciaDto = new MofExperienciaDto();
            mofExperienciaDto.setPuestoDto(this.dto);
            mofExperienciaDto.setCargoDto(this.cargoDto);
            mofExperienciaDto.setAniosExperiencia(this.aniosExperiencia);
            mofExperienciaDto.setDescripcion(this.descripcionExperiencia);
            if(isValidDatosExperiencia(mofExperienciaDto)==false){
                logger.info("Se aborta el grabado de MofExperienciaDto");
                return;
            }
            this.mofExperienciaManager.nuevo(mofExperienciaDto);
            recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.cargoDto = null;
        this.aniosExperiencia = null;
        this.descripcionExperiencia = null;
    }
    
    public void eliminarExperiencia() {
        try {
            this.mofExperienciaManager.eliminar(this.mofExperienciaDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void agregarConducta() {
        try {
            MofConductaDto mofConductaDto = new MofConductaDto();
            mofConductaDto.setPuestoDto(this.dto);
            mofConductaDto.setConductaDto(this.conductaParametroDto);
            mofConductaDto.setDescripcion(this.descripcionConducta);
            if(isValidDatosConducta(mofConductaDto)==false){
                logger.info("Se aborta el grabado de MofConductaDto");
                return;
            }
            this.conductaManager.nuevo(mofConductaDto);
            recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.conductaParametroDto = null;
        this.descripcionConducta = null;
    }
    
    public void eliminarConducta() {
        try {
            this.conductaManager.eliminar(this.conductaDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void agregarConocimientoOfi() {
        try {
            MofConocimientoOfiDto mofConocimientoOfiDto = new MofConocimientoOfiDto();
            mofConocimientoOfiDto.setPuestoDto(this.dto);
            mofConocimientoOfiDto.setHerramientaOfficeDto(this.herramientaOfficeDto);
            mofConocimientoOfiDto.setNivel(this.nivelConocOfi);
            if(isValidDatosConocOfimatica(mofConocimientoOfiDto)==false){
                logger.info("Se aborta el grabado de MofConocimientoOfiDto");
                return;
            }
            this.conocimientoOfiManager.nuevo(mofConocimientoOfiDto);
            recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.herramientaOfficeDto = null;
        this.nivelConocOfi = null;
    }
    
    public void eliminarConocimientoOfi() {
        try {
            this.conocimientoOfiManager.eliminar(this.mofConocimientoOfiDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void agregarConocimientoAdicional() {
        try {
            MofConocimientoAdicionalDto mofConocimientoAdicDto = new MofConocimientoAdicionalDto();
            mofConocimientoAdicDto.setPuestoDto(this.dto);
            mofConocimientoAdicDto.setTitulo(this.tituloConocAdic);
            mofConocimientoAdicDto.setDescripcion(this.descripcionConocAdic);
            mofConocimientoAdicDto.setConocimientoDto(conocimientOficCmacDto);
            if(isValidDatosConocAdicional(mofConocimientoAdicDto)==false){
                logger.info("Se aborta el grabado de MofConocimientoAdicDto");
                return;
            }
            this.conocimientoAdicManager.nuevo(mofConocimientoAdicDto);
            recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.tituloConocAdic = null;
        this.descripcionConocAdic = null;
    }
    
    public void eliminarConocimientoAdicional() {
        try {
            this.conocimientoAdicManager.eliminar(this.mofConocimientoAdicDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void agregarFuncion() {
        int valorA = 5, valorB =0;
        System.out.print(this.valorObjetivo);
        try {
             if(this.valorObjetivo <= valorA && this.valorObjetivo > valorB){
                MofFuncionDto mofFuncionDto = new MofFuncionDto();
                mofFuncionDto.setPuestoDto(this.dto);
                mofFuncionDto.setDescripcion(this.descripcionFuncion);
                mofFuncionDto.setValorObjetivo(this.valorObjetivo);
                mofFuncionDto.setEstadoDto(this.estadoFuncionDto);
                mofFuncionDto.setEvaluacion(this.evaluar);
                /*if(isValidDatosConocAdicional(mofConocimientoAdicDto)==false){
                    logger.info("Se aborta el grabado de MofConocimientoAdicDto");
                    return;
                }*/
                this.mofFuncionManager.nuevo(mofFuncionDto);
                recuperarDtoPadre();
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
             }else{showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.puesto.valor.objetivo.error"));} 
          } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.descripcionFuncion = "";
        this.valorObjetivo = null;
    }
    public void agregarFunSexo() {
        try {
                System.out.print(this.sexoParametroDto.getId());
                int valor=this.mofSexoManager.obtenerMofConductaPorSexoDto(this.sexoParametroDto,this.dto).size();
                System.out.print(valor);
                if(valor==0){
                MofSexoDto mofSexoDto = new MofSexoDto();
                mofSexoDto.setPuestoDto(this.dto);
                mofSexoDto.setSexoDto(this.sexoParametroDto);
                this.mofSexoManager.nuevo(mofSexoDto);
                recuperarDtoPadre();
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
                }else{
                    showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.sexo.error"));
                }
            } catch (Exception ex) {
                logger.error("ERROR DE SISTEMA", ex);
            }
    }
    public void agregarRelaOrgExter() {
        try {
                System.out.print(this.relaOrgExtParametroDto.getId());
                int valor=this.mofRelaOrgExternoManager.obtenerRelaOrgExternDto(this.relaOrgExtParametroDto,this.dto).size();
                System.out.print(valor);
                if(valor==0){
                MofRelaOrgExternoDto mofRelaOrgExternoDto = new MofRelaOrgExternoDto();
                mofRelaOrgExternoDto.setPuestoDto(this.dto);
                mofRelaOrgExternoDto.setExternoDto(this.relaOrgExtParametroDto);
                this.mofRelaOrgExternoManager.nuevo(mofRelaOrgExternoDto);
                recuperarDtoPadre();
                }else{
                    showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.mof.relaciones.organiza"));
                }
            } catch (Exception ex) {
                logger.error("ERROR DE SISTEMA", ex);
            }
    }
    
    
    public void eliminarFuncion() {
        try {
            this.mofFuncionManager.eliminar(this.mofFuncionDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void principal() {
        try {
            this.arbolCompetenciaDto= this.arbolCompetenciaManager.obtenerPropPrincipal(this.dto.getId());
            this.listaArbolCompetenciaFuncionclaveDto = this.arbolCompetenciaManager.obtenerFuncionClave(this.dto.getId());
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    public void listaLineaAutoridad() {
        try {
            MofAutoridadOrganizaDto dtoLineaAuto= new MofAutoridadOrganizaDto();
            dtoLineaAuto.setPuestoDto(this.dto);
            dtoLineaAuto.setTabla(ConstantesSgc.ValoresConstantes.PUESTO_TABLA_LINEA_AUTORIDAD_RESPONSABILIDAD_VALOR);
            dtoLineaAuto.setTipo(ConstantesSgc.ValoresConstantes.PUESTO_TIPO_LINEA_AUTORIDAD_RESPONSABILIDAD_DEPENDENCIA_VALOR);
            
            MofAutoridadOrganizaDto dtoLineaAutoSuper= new MofAutoridadOrganizaDto();
            dtoLineaAutoSuper.setPuestoDto(this.dto);
            dtoLineaAutoSuper.setTabla(ConstantesSgc.ValoresConstantes.PUESTO_TABLA_LINEA_AUTORIDAD_RESPONSABILIDAD_VALOR);
            dtoLineaAutoSuper.setTipo(ConstantesSgc.ValoresConstantes.PUESTO_TIPO_LINEA_AUTORIDAD_RESPONSABILIDAD_SUPERVISION_VALOR);
            
            MofAutoridadOrganizaDto dtoRelacioOrgInterna= new MofAutoridadOrganizaDto();
            dtoRelacioOrgInterna.setPuestoDto(this.dto);
            dtoRelacioOrgInterna.setTabla(ConstantesSgc.ValoresConstantes.PUESTO_TABLA_RELACIONES_ORGANIZACIONALES_VALOR);
            dtoRelacioOrgInterna.setTipo(ConstantesSgc.ValoresConstantes.PUESTO_TIPO_RELACIONES_ORGANIZACIONALES_INTERNAS_VALOR);
            
            this.listaLineaAutoridad= this.mofAutoridadOrganizaManager.obtenerMofAutoridadOrganizaPorTablaTipo(dtoLineaAuto);
            this.listaLineaAutoridadSupervision= this.mofAutoridadOrganizaManager.obtenerMofAutoridadOrganizaPorTablaTipo(dtoLineaAutoSuper);
            this.listaRelacionesOrgInt= this.mofAutoridadOrganizaManager.obtenerMofAutoridadOrganizaPorTablaTipo(dtoRelacioOrgInterna);

        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public void eliminarFunSexo() {
        try {
            this.mofSexoManager.eliminar(this.mofSexoDto);
            this.recuperarDtoPadre();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    protected void recuperarDtoPadre() {
        try {
            this.dto = this.manager.obtenerPorId(this.dto.getId());
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
    
    public List<PuestoDto> autoCompletarPuesto(String query) {

        PuestoManager manager = (PuestoManager) WebServletContextListener.getApplicationContext().getBean("puestoManager");
        List<PuestoDto> results = null;
        try {

            results = manager.obtenerPuestosActivos(query);
        } catch (DAOException ex) {
            logger.error(ex);
            results = new ArrayList<PuestoDto>();
        }
        return results;
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void setLogger(Logger logger) {
        PuestoMBean.logger = logger;
    }

    public PuestoManager getManager() {
        return manager;
    }

    public void setManager(PuestoManager manager) {
        this.manager = manager;
    }
    
    public RecursosManager getRecursosManager() {
        return recursosManager;
    }

    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }

    public List<PuestoDto> getLista() {
        return lista;
    }

    public void setLista(List<PuestoDto> lista) {
        this.lista = lista;
    }

    public PuestoDto getDto() {
        return dto;
    }

    public void setDto(PuestoDto dto) {
        this.dto = dto;
    }

    public PuestoDto getDtoFiltro() {
        return dtoFiltro;
    }

    public void setDtoFiltro(PuestoDto dtoFiltro) {
        this.dtoFiltro = dtoFiltro;
    }

    public String getKeyTitulo() {
        return keyTitulo;
    }

    public void setKeyTitulo(String keyTitulo) {
        this.keyTitulo = keyTitulo;
    }

    public ApplicationMBean getApplicationMBean() {
        return applicationMBean;
    }

    public void setApplicationMBean(ApplicationMBean applicationMBean) {
        this.applicationMBean = applicationMBean;
    }
    
    public Boolean getAccesoBtnGuardar() {
        return accesoBtnGuardar;
    }

    public void setAccesoBtnGuardar(Boolean accesoBtnGuardar) {
        this.accesoBtnGuardar = accesoBtnGuardar;
    }

    public SessionMBean getSessionMBean() {
        return sessionMBean;
    }

    public void setSessionMBean(SessionMBean sessionMBean) {
        this.sessionMBean = sessionMBean;
    }

    public List<ParametroDto> getListaFamiliaNuevo() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSgc.CatalogoParametro.FAMILIA_PUESTOS);
    }

    public void setListaFamiliaNuevo(List<ParametroDto> listaFamiliaNuevo) {
        this.listaFamiliaNuevo = listaFamiliaNuevo;
    }

    public List<ParametroDto> getListaFamiliaFiltro() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistemaAdd(ConstantesSgc.CatalogoParametro.FAMILIA_PUESTOS, ConstantesCore.Parametro.TODOS);
    }

    public void setListaFamiliaFiltro(List<ParametroDto> listaFamiliaFiltro) {
        this.listaFamiliaFiltro = listaFamiliaFiltro;
    }

    public MofConductaManager getConductaManager() {
        return conductaManager;
    }

    public void setConductaManager(MofConductaManager conductaManager) {
        this.conductaManager = conductaManager;
    }

    public MofConocimientoAdicManager getConocimientoAdicManager() {
        return conocimientoAdicManager;
    }

    public void setConocimientoAdicManager(MofConocimientoAdicManager conocimientoAdicManager) {
        this.conocimientoAdicManager = conocimientoAdicManager;
    }

    public MofConocimientoOfiManager getConocimientoOfiManager() {
        return conocimientoOfiManager;
    }

    public void setConocimientoOfiManager(MofConocimientoOfiManager conocimientoOfiManager) {
        this.conocimientoOfiManager = conocimientoOfiManager;
    }
    
    public MofConductaDto getConductaDto() {
        return conductaDto;
    }

    public void setConductaDto(MofConductaDto conductaDto) {
        this.conductaDto = conductaDto;
    }

    public ParametroDto getConductaParametroDto() {
        return conductaParametroDto;
    }

    public void setConductaParametroDto(ParametroDto conductaParametroDto) {
        this.conductaParametroDto = conductaParametroDto;
    }

    public String getDescripcionConducta() {
        return descripcionConducta;
    }

    public void setDescripcionConducta(String descripcionConducta) {
        this.descripcionConducta = descripcionConducta;
    }

    public ParametroDto getCargoDto() {
        return cargoDto;
    }

    public void setCargoDto(ParametroDto cargoDto) {
        this.cargoDto = cargoDto;
    }

    public Integer getAniosExperiencia() {
        return aniosExperiencia;
    }

    public void setAniosExperiencia(Integer aniosExperiencia) {
        this.aniosExperiencia = aniosExperiencia;
    }

    public String getDescripcionExperiencia() {
        return descripcionExperiencia;
    }

    public void setDescripcionExperiencia(String descripcionExperiencia) {
        this.descripcionExperiencia = descripcionExperiencia;
    }

    public ParametroDto getProfesionDto() {
        return profesionDto;
    }

    public void setProfesionDto(ParametroDto profesionDto) {
        this.profesionDto = profesionDto;
    }
    
    public List<ParametroDto> getListaProfesion() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCore.CatalogoParametro.AREA_ESTUDIO);
    }

    public void setListaProfesion(List<ParametroDto> listaProfesion) {
        this.listaProfesion = listaProfesion;
    }

    public String getOral() {
        return oral;
    }

    public void setOral(String oral) {
        this.oral = oral;
    }

    public String getEscrito() {
        return escrito;
    }

    public void setEscrito(String escrito) {
        this.escrito = escrito;
    }

    public ParametroDto getIdiomaParametroDto() {
        return idiomaParametroDto;
    }

    public void setIdiomaParametroDto(ParametroDto idiomaParametroDto) {
        this.idiomaParametroDto = idiomaParametroDto;
    }

    public List<ParametroDto> getListaEstadosPuesto() {
       List<ParametroDto> list = new ArrayList<ParametroDto>();
       for(ParametroDto param : this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSgc.CatalogoParametro.PUESTO_ESTADOS)){
           if(!param.getId().equals(ConstantesSgc.Parametro.PUESTO_ESTADO_HABILITADO)){
               list.add(param);
           }
       }
       return list;
    }

    public List<ParametroDto> getListaEstadosPuestoHab() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSgc.CatalogoParametro.PUESTO_ESTADOS);
    }

    public void setListaEstadosPuestoHab(List<ParametroDto> listaEstadosPuestoHab) {
        this.listaEstadosPuestoHab = listaEstadosPuestoHab;
    }

    public void setListaEstadosPuesto(List<ParametroDto> listaEstadosPuesto) {
        this.listaEstadosPuesto = listaEstadosPuesto;
    }

    public List<ParametroDto> getListaUnidadOrganica() {
       List<ParametroDto> list = new ArrayList<ParametroDto>();
       for(ParametroDto param : this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSgc.CatalogoParametro.UNIDAD_ORGANICA)){
               list.add(param);
       }
       return list;
    }

    public void setListaUnidadOrganica(List<ParametroDto> listaUnidadOrganica) {
        this.listaUnidadOrganica = listaUnidadOrganica;
    }

    public List<ParametroDto> getListaUnidadOrganicaFiltro() {
       List<ParametroDto> list = new ArrayList<ParametroDto>();
       for(ParametroDto param : this.recursosManager.obtenerParametrosActivosPorCatalogoSistemaAdd(ConstantesSgc.CatalogoParametro.UNIDAD_ORGANICA, ConstantesCore.Parametro.TODOS)){
               list.add(param);
       }
       return list;
    }

    public void setListaUnidadOrganicaFiltro(List<ParametroDto> listaUnidadOrganicaFiltro) {
        this.listaUnidadOrganicaFiltro = listaUnidadOrganicaFiltro;
    }
    
    public List<ParametroDto> getListaIdioma() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCore.CatalogoParametro.IDIOMAS_DEL_SISTEMA);
    }

    public void setListaIdioma(List<ParametroDto> listaIdioma) {
        this.listaIdioma = listaIdioma;
    }

    public List<ParametroDto> getListaAreas() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSgc.CatalogoParametro.AREA);
    }

    public void setListaAreas(List<ParametroDto> listaAreas) {
        this.listaAreas = listaAreas;
    }

    
    public String getTituloConocAdic() {
        return tituloConocAdic;
    }

    public void setTituloConocAdic(String tituloConocAdic) {
        this.tituloConocAdic = tituloConocAdic;
    }

    public String getDescripcionConocAdic() {
        return descripcionConocAdic;
    }

    public void setDescripcionConocAdic(String descripcionConocAdic) {
        this.descripcionConocAdic = descripcionConocAdic;
    }

    public ParametroDto getHerramientaOfficeDto() {
        return herramientaOfficeDto;
    }

    public void setHerramientaOfficeDto(ParametroDto herramientaOfficeDto) {
        this.herramientaOfficeDto = herramientaOfficeDto;
    }

    public String getNivelConocOfi() {
        return nivelConocOfi;
    }

    public void setNivelConocOfi(String nivelConocOfi) {
        this.nivelConocOfi = nivelConocOfi;
    }

    public MofFuncionDto getMofFuncionDto() {
        return mofFuncionDto;
    }

    public void setMofFuncionDto(MofFuncionDto mofFuncionDto) {
        this.mofFuncionDto = mofFuncionDto;
    }

    public String getDescripcionFuncion() {
        return descripcionFuncion;
    }

    public void setDescripcionFuncion(String descripcionFuncion) {
        this.descripcionFuncion = descripcionFuncion;
    }

    public Integer getValorObjetivo() {
        return valorObjetivo;
    }

    public void setValorObjetivo(Integer valorObjetivo) {
        this.valorObjetivo = valorObjetivo;
    }

    public ParametroDto getEstadoFuncionDto() {
        return estadoFuncionDto;
    }

    public void setEstadoFuncionDto(ParametroDto estadoFuncionDto) {
        this.estadoFuncionDto = estadoFuncionDto;
    }

    public MofEstudioManager getMofEstudioManager() {
        return mofEstudioManager;
    }

    public void setMofEstudioManager(MofEstudioManager mofEstudioManager) {
        this.mofEstudioManager = mofEstudioManager;
    }

    public MofExperienciaManager getMofExperienciaManager() {
        return mofExperienciaManager;
    }

    public void setMofExperienciaManager(MofExperienciaManager mofExperienciaManager) {
        this.mofExperienciaManager = mofExperienciaManager;
    }

    public MofIdiomaManager getMofIdiomaManager() {
        return mofIdiomaManager;
    }

    public void setMofIdiomaManager(MofIdiomaManager mofIdiomaManager) {
        this.mofIdiomaManager = mofIdiomaManager;
    }

    public MofFuncionManager getMofFuncionManager() {
        return mofFuncionManager;
    }

    public void setMofFuncionManager(MofFuncionManager mofFuncionManager) {
        this.mofFuncionManager = mofFuncionManager;
    }

    public MofExperienciaDto getMofExperienciaDto() {
        return mofExperienciaDto;
    }

    public void setMofExperienciaDto(MofExperienciaDto mofExperienciaDto) {
        this.mofExperienciaDto = mofExperienciaDto;
    }

    public MofEstudioDto getMofEstudioDto() {
        return mofEstudioDto;
    }

    public void setMofEstudioDto(MofEstudioDto mofEstudioDto) {
        this.mofEstudioDto = mofEstudioDto;
    }

    public MofIdiomaDto getMofIdiomaDto() {
        return mofIdiomaDto;
    }

    public void setMofIdiomaDto(MofIdiomaDto mofIdiomaDto) {
        this.mofIdiomaDto = mofIdiomaDto;
    }

    public MofConocimientoAdicionalDto getMofConocimientoAdicDto() {
        return mofConocimientoAdicDto;
    }

    public void setMofConocimientoAdicDto(MofConocimientoAdicionalDto mofConocimientoAdicDto) {
        this.mofConocimientoAdicDto = mofConocimientoAdicDto;
    }

    public MofConocimientoOfiDto getMofConocimientoOfiDto() {
        return mofConocimientoOfiDto;
    }

    public void setMofConocimientoOfiDto(MofConocimientoOfiDto mofConocimientoOfiDto) {
        this.mofConocimientoOfiDto = mofConocimientoOfiDto;
    }

    public List<ParametroDto> getListaConducta() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCore.CatalogoParametro.CONDUCTA);
    }

    public void setListaConducta(List<ParametroDto> listaConducta) {
        this.listaConducta = listaConducta;
    }

    public List<ParametroDto> getListaHerramientaOffice() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCore.CatalogoParametro.HERRAMIENTA_INFORMATICA);
    }

    public void setListaHerramientaOffice(List<ParametroDto> listaHerramientaOffice) {
        this.listaHerramientaOffice = listaHerramientaOffice;
    }

    public Long getNumeroPuestoHabilitado() {
        return numeroPuestoHabilitado=ConstantesSgc.Parametro.PUESTO_ESTADO_HABILITADO;
    }

    public void setNumeroPuestoHabilitado(Long numeroPuestoHabilitado) {
        this.numeroPuestoHabilitado = numeroPuestoHabilitado;
    }

    public Boolean getEvaluar() {
        return evaluar;
    }

    public void setEvaluar(Boolean evaluar) {
        this.evaluar = evaluar;
    }

    public MofSexoDto getMofSexoDto() {
        return mofSexoDto;
    }

    public void setMofSexoDto(MofSexoDto mofSexoDto) {
        this.mofSexoDto = mofSexoDto;
    }

    public ParametroDto getSexoParametroDto() {
        return sexoParametroDto;
    }

    public void setSexoParametroDto(ParametroDto sexoParametroDto) {
        this.sexoParametroDto = sexoParametroDto;
    }

    public List<ParametroDto> getListaSexo() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCore.CatalogoParametro.SEXO);
    }

    public void setListaSexo(List<ParametroDto> listaSexo) {
        this.listaSexo = listaSexo;
    }

    public ArbolCompetenciaDto getArbolCompetenciaDto() {
        return arbolCompetenciaDto;
    }

    public void setArbolCompetenciaDto(ArbolCompetenciaDto arbolCompetenciaDto) {
        this.arbolCompetenciaDto = arbolCompetenciaDto;
    }

    public List<ArbolCompetenciaDto> getListaArbolCompetenciaFuncionclaveDto() {
        return listaArbolCompetenciaFuncionclaveDto;
    }

    public void setListaArbolCompetenciaFuncionclaveDto(List<ArbolCompetenciaDto> listaArbolCompetenciaFuncionclaveDto) {
        this.listaArbolCompetenciaFuncionclaveDto = listaArbolCompetenciaFuncionclaveDto;
    }

    public MofAutoridadOrganizaDto getMofLineaAutoridadDto() {
        return mofLineaAutoridadDto;
    }

    public void setMofLineaAutoridadDto(MofAutoridadOrganizaDto mofLineaAutoridadDto) {
        this.mofLineaAutoridadDto = mofLineaAutoridadDto;
    }

    public List<MofAutoridadOrganizaDto> getListaLineaAutoridad() {
        return listaLineaAutoridad;
    }

    public void setListaLineaAutoridad(List<MofAutoridadOrganizaDto> listaLineaAutoridad) {
        this.listaLineaAutoridad = listaLineaAutoridad;
    }

    public Boolean getDesabilitarBotonProcesar() {
        return desabilitarBotonProcesar;
    }

    public void setDesabilitarBotonProcesar(Boolean desabilitarBotonProcesar) {
        this.desabilitarBotonProcesar = desabilitarBotonProcesar;
    }

    public Boolean getDesabilitarBotonProcesarSupervision() {
        return desabilitarBotonProcesarSupervision;
    }

    public void setDesabilitarBotonProcesarSupervision(Boolean desabilitarBotonProcesarSupervision) {
        this.desabilitarBotonProcesarSupervision = desabilitarBotonProcesarSupervision;
    }

    public List<MofAutoridadOrganizaDto> getListaLineaAutoridadSupervision() {
        return listaLineaAutoridadSupervision;
    }

    public void setListaLineaAutoridadSupervision(List<MofAutoridadOrganizaDto> listaLineaAutoridadSupervision) {
        this.listaLineaAutoridadSupervision = listaLineaAutoridadSupervision;
    }

    public MofAutoridadOrganizaDto getMofRelacionesOrgani() {
        return mofRelacionesOrgani;
    }

    public void setMofRelacionesOrgani(MofAutoridadOrganizaDto mofRelacionesOrgani) {
        this.mofRelacionesOrgani = mofRelacionesOrgani;
    }

    public List<MofAutoridadOrganizaDto> getListaRelacionesOrgInt() {
        return listaRelacionesOrgInt;
    }

    public void setListaRelacionesOrgInt(List<MofAutoridadOrganizaDto> listaRelacionesOrgInt) {
        this.listaRelacionesOrgInt = listaRelacionesOrgInt;
    }

    public Boolean getDesabilitarBotonRelacionesOrg() {
        return desabilitarBotonRelacionesOrg;
    }

    public void setDesabilitarBotonRelacionesOrg(Boolean desabilitarBotonRelacionesOrg) {
        this.desabilitarBotonRelacionesOrg = desabilitarBotonRelacionesOrg;
    }

    public List<ParametroDto> getListaRelaOrgInternas() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSgc.CatalogoParametro.RELACIONES_ORGANIZACIONALES_EXTERNAS);
    }

    public void setListaRelaOrgInternas(List<ParametroDto> listaRelaOrgInternas) {
        this.listaRelaOrgInternas = listaRelaOrgInternas;
    }

    public MofRelaOrgExternoManager getMofRelaOrgExternoManager() {
        return mofRelaOrgExternoManager;
    }

    public void setMofRelaOrgExternoManager(MofRelaOrgExternoManager mofRelaOrgExternoManager) {
        this.mofRelaOrgExternoManager = mofRelaOrgExternoManager;
    }

    public MofRelaOrgExternoDto getMofRelaOrgExternoDto() {
        return mofRelaOrgExternoDto;
    }

    public void setMofRelaOrgExternoDto(MofRelaOrgExternoDto mofRelaOrgExternoDto) {
        this.mofRelaOrgExternoDto = mofRelaOrgExternoDto;
    }

    public ParametroDto getRelaOrgExtParametroDto() {
        return relaOrgExtParametroDto;
    }

    public void setRelaOrgExtParametroDto(ParametroDto relaOrgExtParametroDto) {
        this.relaOrgExtParametroDto = relaOrgExtParametroDto;
    }

    public List<ParametroDto> getListaConocimienInforCMAC() {
       return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesCore.CatalogoParametro.CONOCIMIENTO_INFORMATICO_CMAC);
    }

    public void setListaConocimienInforCMAC(List<ParametroDto> listaConocimienInforCMAC) {
        this.listaConocimienInforCMAC = listaConocimienInforCMAC;
    } 

    public ParametroDto getConocimientOficCmacDto() {
        return conocimientOficCmacDto;
    }

    public void setConocimientOficCmacDto(ParametroDto conocimientOficCmacDto) {
        this.conocimientOficCmacDto = conocimientOficCmacDto;
    }
    
}
